package com.tanhua.server.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.tanhua.common.mapper.*;
import com.tanhua.common.pojo.*;
import com.tanhua.common.utils.UserThreadLocal;
import com.tanhua.server.vo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * 测灵魂业务层
 */
@Service
public class TestSoulService {

    //用户锁
    @Autowired
    private QuestionUserLockMapper questionUserLockMapper;

    //问卷
    @Autowired
    private QuestionnaireMapper questionnaireMapper;

    //问题
    @Autowired
    private SoulQuestionMapper soulQuestionMapper;

    //问题选项
    @Autowired
    private SoulQuestionOptionMapper soulQuestionOptionMapper;

    //灵魂题目结果表(固定)
    @Autowired
    private QuestionnaireResultMapper questionnaireResultMapper;

    @Autowired
    private QuestionnaireReportMapper questionnaireReportMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 查询问卷列表
     *
     * @return
     */
    public List<QuestionnaireVo> queryTestSoul() {
        //获取当前登录用户
        User user = UserThreadLocal.get();
        //创建一个空集合存储返回的vo对象
        List<QuestionnaireVo> questionnaireVoList = new ArrayList<>();


        //通过用户id查询到对应的用户锁表
        QueryWrapper<QuestionUserLock> queryQuestionUserLock = new QueryWrapper<>();
        queryQuestionUserLock.eq("user_id", user.getId());
        List<QuestionUserLock> questionUserLockList = questionUserLockMapper.selectList(queryQuestionUserLock);

        //判断当前用户是否做过问卷
        if (CollUtil.isEmpty(questionUserLockList)) {
            //设置默认的值
            QuestionUserLock questionUserLock = new QuestionUserLock(null, user.getId(), 1l, 0);
            QuestionUserLock questionUserLock1 = new QuestionUserLock(null, user.getId(), 2l, 1);
            QuestionUserLock questionUserLock2 = new QuestionUserLock(null, user.getId(), 3l, 1);
            //添加数据
            questionUserLockMapper.insert(questionUserLock);
            questionUserLockMapper.insert(questionUserLock1);
            questionUserLockMapper.insert(questionUserLock2);
            questionUserLockList.add(questionUserLock);
            questionUserLockList.add(questionUserLock1);
            questionUserLockList.add(questionUserLock2);
        }

        //获取问卷报告中的数据
        //先从问卷报告表中获取数据
        QueryWrapper<QuestionnaireReport> queryReport = new QueryWrapper<>();
        queryReport.eq("user_id",user.getId());
        List<QuestionnaireReport> questionnaireReports = this.questionnaireReportMapper.selectList(queryReport);

        //将用户表锁中的数据进行填充
        for (QuestionUserLock questionUserLock : questionUserLockList) {
            QuestionnaireVo questionnaireVo = new QuestionnaireVo();
            questionnaireVo.setId(questionUserLock.getQuestionnaireId().toString());
            questionnaireVo.setIsLock(questionUserLock.getIsLock());

            //判断是否是第一次获取报告id
            for (QuestionnaireReport questionnaireReport : questionnaireReports) {
                if (questionnaireReport.getQuestionnaireId() == questionUserLock.getQuestionnaireId() && questionUserLock.getIsLock() == 0){
                    questionnaireVo.setReportId(String.valueOf(questionnaireReport.getId()));
                }
            }

            questionnaireVoList.add(questionnaireVo);

        }

        //获取当前用户可以访问的问卷的id集合
        List<Long> questionnaireIdList = new ArrayList<>();
        for (QuestionUserLock questionUserLock : questionUserLockList) {
            questionnaireIdList.add(questionUserLock.getQuestionnaireId());
        }

        //通过问卷的id进行查询对应的问题表 进行封装
        QueryWrapper<Questionnaire> qwByQuestionnaireId = new QueryWrapper<>();
        qwByQuestionnaireId.in("id", questionnaireIdList);
        List<Questionnaire> questionnaireList = questionnaireMapper.selectList(qwByQuestionnaireId);
        for (Questionnaire questionnaire : questionnaireList) {
            for (QuestionnaireVo questionnaireVo : questionnaireVoList) {
                if (questionnaireVo.getId().equals(questionnaire.getId().toString())) {
                    //填充数据
                    questionnaireVo.setLevel(Convert.toStr(questionnaire.getLevel().getValue()));
                    questionnaireVo.setName(questionnaire.getName());
                    questionnaireVo.setStar(questionnaire.getStar());
                    questionnaireVo.setCover(questionnaire.getCover());
                }
            }
        }

        //设置SoulQuestionVo,将SoulQuestion中对应的数据进行填充
        //进行数据填充
        for (QuestionnaireVo questionnaireVo : questionnaireVoList) {
            //首先查询出SoulQuestion的问题数据
            QueryWrapper<SoulQuestion> qwSoulQuestionById = new QueryWrapper<>();
            qwSoulQuestionById.in("questionnaire_id", questionnaireIdList);
            List<SoulQuestion> soulQuestionList = soulQuestionMapper.selectList(qwSoulQuestionById);

            //试题vo
            List<SoulQuestionVo> soulQuestionVoList = new ArrayList<>();

            for (SoulQuestion soulQuestion : soulQuestionList) {
                if (soulQuestion.getQuestionnaireId().toString().equals(questionnaireVo.getId())) {
                    SoulQuestionVo soulQuestionVo = new SoulQuestionVo();
                    //设置问题
                    soulQuestionVo.setQuestion(soulQuestion.getStem());
                    soulQuestionVo.setId(soulQuestion.getId().toString());
                    soulQuestionVoList.add(soulQuestionVo);
                    //设置问题对应的选项
                    //问题id的集合
                    List<Object> SoulQuestionIdList = CollUtil.getFieldValues(soulQuestionList, "id");

                    List<SoulQuestionOptionVo> soulQuestionOptionVoList = new ArrayList<>();

                    //问题对应的选项
                    QueryWrapper<SoulQuestionOption> qwSoulQuestionOptionById = new QueryWrapper<>();
                    qwSoulQuestionOptionById.in("question_id", SoulQuestionIdList);
                    List<SoulQuestionOption> soulQuestionOptionList = soulQuestionOptionMapper.selectList(qwSoulQuestionOptionById);

                    for (SoulQuestionOption soulQuestionOption : soulQuestionOptionList) {
                        if (soulQuestionOption.getQuestionId().equals(soulQuestion.getId())) {
                            SoulQuestionOptionVo soulQuestionOptionVo = new SoulQuestionOptionVo();
                            soulQuestionOptionVo.setOption(soulQuestionOption.getContent());
                            soulQuestionOptionVo.setId(soulQuestion.getId().toString());
                            soulQuestionOptionVoList.add(soulQuestionOptionVo);
                        }
                    }
                    soulQuestionVo.setOptions(soulQuestionOptionVoList);
                }
            }

            //把问题对象填充到返回问卷vo对象
            questionnaireVo.setQuestions(soulQuestionVoList);
        }
        return questionnaireVoList;
    }


    /**
     * 提交问卷
     *
     * @param answersList 用户的答卷列表
     */
    public String saveAnswers(List<Answers> answersList) {
        User user = UserThreadLocal.get();
        int score = 0;
        Long questionId = 0L;
        //查询获取分数
        for (Answers answers : answersList) {
            //问题id
            questionId = answers.getQuestionId();
            //选项id
            Long optionId = answers.getOptionId();

            //通过问题的id在SoulQuestionOption中查询到对应的分值,并尽心累加求和
            QueryWrapper<SoulQuestionOption> qwQuestionOptionById = new QueryWrapper<>();
            qwQuestionOptionById.eq("id", optionId);
            SoulQuestionOption soulQuestionOption = soulQuestionOptionMapper.selectOne(qwQuestionOptionById);

            score += Integer.parseInt(soulQuestionOption.getScore());
        }

        System.out.println(score);

        //查询用户所做的问卷,开启下一等级
        SoulQuestion soulQuestion = soulQuestionMapper.selectById(questionId);
        Long questionnaireId = soulQuestion.getQuestionnaireId();

        //判断当前的用户等级   若当前等级不超过2级 并且锁表小于2条则更新数据
        //通过当前用户获取到对应的用户锁表
        QueryWrapper<QuestionUserLock> queryUserlock = new QueryWrapper<>();
        queryUserlock.in("user_id", user.getId());
        List<QuestionUserLock> userLockList = questionUserLockMapper.selectList(queryUserlock);
        QueryWrapper<QuestionUserLock> queryWarpper = new QueryWrapper<>();
        for (QuestionUserLock questionUserLock : userLockList) {
            if (questionUserLock.getQuestionnaireId().equals(questionnaireId + 1) && questionUserLock.getIsLock().equals(1)) {
                queryWarpper.eq("questionnaire_id", questionnaireId + 1);
                questionUserLock.setIsLock(0);
                questionUserLockMapper.update(questionUserLock, queryWarpper);
                break;
            }
        }


        //查询tb_questionnaire_result表,判断分值处于哪一个区间内 ,并填充数据
        QueryWrapper<QuestionnaireResult> qwquestionnaireResult = new QueryWrapper<>();
        qwquestionnaireResult.eq("questionnaire_id", questionnaireId);
        List<QuestionnaireResult> questionnaireResultList = questionnaireResultMapper.selectList(qwquestionnaireResult);

        //进行数据填充 对应用户的数据保存表
        QuestionnaireReport questionnaireReport = new QuestionnaireReport();

        //遍历结果表,查询
        for (QuestionnaireResult questionnaireResult : questionnaireResultList) {
            String[] scopeArr = StrUtil.split(questionnaireResult.getScope(), ",");
            if (score >= Integer.valueOf(scopeArr[0]) && score <= Integer.valueOf(scopeArr[1])) {
                //进行数据填充到用户结果表中
                questionnaireReport.setConclusionId(questionnaireResult.getId());
                questionnaireReport.setUserId(user.getId());
                questionnaireReport.setCover(questionnaireResult.getCover());
                //todo 对应的外挂得分,判断得分,抽象得分,理性得分未设置  设置默认数据
                questionnaireReport.setRetionality("80%");
                questionnaireReport.setAbstraction("92%");
                questionnaireReport.setJudgement("89%");
                questionnaireReport.setExtroversion("75%");
                questionnaireReport.setQuestionnaireId(questionnaireId);
            }
        }

        //查询用户的报告表


        //通过问卷id查询用户之前是否做过该问卷
        QueryWrapper<QuestionnaireReport> queryReport =new QueryWrapper<>();
        queryReport.eq("questionnaire_id",questionnaireReport.getQuestionnaireId());
        List<QuestionnaireReport> questionnaireReports = questionnaireReportMapper.selectList(queryReport);
        //遍历用户数据表
        for (QuestionnaireReport report : questionnaireReports) {
            //如果有与用户id相等的,则进行升级
            if (questionnaireReport.getUserId() == report.getUserId()){
                QueryWrapper<QuestionnaireReport> queryUpdate = new QueryWrapper<>();
                queryUpdate.eq("user_id",user.getId()).eq("questionnaire_id",questionnaireId);
                questionnaireReport.setUpdated(new Date());
                this.questionnaireReportMapper.update(questionnaireReport,queryUpdate);
                return String.valueOf(report.getId());
            }
        }

        //否则进行新增
        questionnaireReport.setCreated(new Date());
        //添加到数据库中
        questionnaireReportMapper.insert(questionnaireReport);

        return questionnaireReport.getId().toString();
    }

    /**
     * 测试结果
     *
     * @param id 报告id
     * @return
     */
    public TestResultVo testResult(Long id) {

//获取当前登录用户的id
        User user = UserThreadLocal.get();
        //根据报告id查询指定的报告
        QuestionnaireReport questionnaireReport = this.questionnaireReportMapper.selectById(id);
        if (ObjectUtil.isEmpty(questionnaireReport)){
            return null;
        }
        TestResultVo testSoulResultVo = new TestResultVo();
        //根据查询的报告,查找对应的测试结果
        QuestionnaireResult questionnaireResult = this.questionnaireResultMapper.selectById(questionnaireReport.getConclusionId());

        testSoulResultVo.setConclusion(questionnaireResult.getContent());
        testSoulResultVo.setCover(questionnaireResult.getCover());

        //维度
        List<Dimensions> dimensionsVoList = new ArrayList<>();
        //通过报告表里面的ConclusionId查询数据，写维度集合里
        dimensionsVoList.add(new Dimensions("外向", questionnaireReport.getExtroversion()));
        dimensionsVoList.add(new Dimensions("判断", questionnaireReport.getJudgement()));
        dimensionsVoList.add(new Dimensions("抽象", questionnaireReport.getAbstraction()));
        dimensionsVoList.add(new Dimensions("理性", questionnaireReport.getRetionality()));

        testSoulResultVo.setDimensions(dimensionsVoList);

        //推荐相似好友
        //通过报告表根据类型查询相似用户id
        QueryWrapper<QuestionnaireReport> queryMapper = new QueryWrapper<>();
        queryMapper.eq("conclusion_id",questionnaireReport.getConclusionId());
        List<QuestionnaireReport> questionnaireReports = questionnaireReportMapper.selectList(queryMapper);
        List<SimilarYou> similarYouList = new ArrayList<>();
        for (QuestionnaireReport report : questionnaireReports) {
            //通过查询的用户id去查询用户的具体信息
            //排除自己
            if (report.getUserId() == user.getId()){
                continue;
            }
            UserInfo userInfo = userInfoMapper.selectById(report.getUserId());
            SimilarYou similarYouVo = new SimilarYou();
            similarYouVo.setId(report.getUserId());
            similarYouVo.setAvatar(userInfo.getLogo());

            similarYouList.add(similarYouVo);
        }
        testSoulResultVo.setSimilarYou(similarYouList);

        return testSoulResultVo;


    }

}
